package com.aiguigu.stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Stream;

public class TestStream {
    /*
    一.创建stream
      1.可以通过Collection 系列集合提供的stream()或parallelStream()
      2.通过Arrays中的静态方法Stream()获取数组流
      3.通过stream类中的静态方法of()
      4.创建无限流
        1)Stream.iterate()
        2)Stream.generate()
    二.中间操作
      1.
    三.终止操作
    除非触发了终止操作,否则中间操作不会执行,即"惰性求值"

    * */
    public static void main(String[] args) {
       /* List<String>list =new ArrayList<>();
        Stream<String> stream = list.stream();
        Employee [] employees = new Employee[10];
        Stream<Employee> stream1 = Arrays.stream(employees);
        Stream<String> stream2 = Stream.of("aa", "bb", "cc");
*/
        List<Employee> employeeList = Arrays.asList(
                new Employee(18, "张三", "上海"),
                new Employee(35, "李四", "上海"),
                new Employee(22, "王五", "上海"),
                new Employee(19, "张三", "上海"),
                new Employee(40, "张三", "上海")
        );


/*
        employeeList.stream().map(employee -> {
           return employee.getName();
        }).forEach(System.out::println);

        Stream stream = employeeList.stream().filter((employee -> {
            return employee.getAge() > 20;
        }));
        stream.limit(2).forEach(System.out::println);
        employeeList.stream().skip(2).forEach(System.out::println);
*/
        /*
         * 映射
         *  map:接受一个lambda,将元素转换成其他形式或提取信息.接受一个函数为参数,该函数会被应用到每个元素上,并将其映射成一个新元素.
         * flatMap:接受一个函数为参数,将流中的每个值都换成另一个流,然后把所有流连接成一个流
         * */
      /*  List<String> stringList = Arrays.asList("aaa", "bbb", "ccc", "ddd");
        stringList.stream().map((str)->str.toUpperCase()).forEach(System.out::println);*/


      /*
      * 排序:sort
      * */


      /*
      * 终止操作:
      *   allmatch  检查是否匹配所有元素 返回一个boolean
      *   anymatch  是否至少匹配一个元素  返回一个boolean
      *   nonematch  是否没有匹配的元素
      * findfirst  返回第一个元素
      * anymatch    返回当前流中任意一个元素
      * count max min
      *
      * 规约:
      *   reduce(T identity(起始值),BinaryOperator(二元运算)) 将流中元素反复结合起来,得到一个值
      *收集:
      *  collect
      *   将流转换为其他形式.接收一个Collector接口的实现,用于给Stream中的元素做汇总方法
      *   .collect(Collectors.toList())) .collect(Collectors.toCollection(HashSet::new))
      *    分组:
      *       .collect(Collectors.groupingBy(Employee::getName))
      *    多级分组:
      *
      * */
        Optional<Integer> reduce1 = employeeList.stream().map(Employee::getAge).reduce(Integer::sum);
        Integer integer = reduce1.get();
        System.out.println(integer);

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Integer reduce = list.stream().reduce(0, (x, y) -> x + y);
        //先把起始值作为x,流中取出一个元素y,结果为新x,再取出一个元素为y
        System.out.println(reduce);
    }
}
